/**
 * Copyright (c) qzsoft All rights reserved.
 * <p>
 * qzsoft.cn
 * <p>
 * 版权所有，侵权必究！
 */

package com.qzsoft.system.modules.permission.dept.service.impl;

import cn.hutool.core.convert.Convert;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.qzsoft.jeemis.common.constant.Constant;
import com.qzsoft.jeemis.common.enums.SuperAdminEnum;
import com.qzsoft.jeemis.common.exception.ErrorCode;
import com.qzsoft.jeemis.common.exception.RenException;
import com.qzsoft.jeemis.common.service.BaseService;
import com.qzsoft.jeemis.common.utils.ConvertDictUtils;
import com.qzsoft.jeemis.common.utils.ConvertUtils;
import com.qzsoft.jeemis.common.utils.Ten2ThirtyUtils;
import com.qzsoft.jeemis.common.utils.TreeNode;
import com.qzsoft.jeemis.platform.security.user.UserDetail;
import com.qzsoft.system.common.CommonUtils;
import com.qzsoft.system.config.SysDeptConfig;
import com.qzsoft.system.modules.permission.dept.dao.SysDeptExtDao;
import com.qzsoft.system.modules.permission.dept.dao.SysDeptMapper;
import com.qzsoft.system.modules.permission.dept.dto.SysDeptDTO;
import com.qzsoft.system.modules.permission.dept.dto.SysDeptTreeDto2;
import com.qzsoft.system.modules.permission.dept.excel.SysDeptExcel;
import com.qzsoft.system.modules.permission.dept.service.SysDeptService;
import com.qzsoft.system.repository.sys.dao.SysUserDao;
import com.qzsoft.system.repository.sys.entity.SysDeptEntity;
import com.qzsoft.system.repository.sys.entity.SysUserEntity;
import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.util.Assert;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;


/**
 * @author sdmq
 */
@Service
public class SysDeptServiceImpl extends BaseService implements SysDeptService {

    @Autowired
    SysDeptExtDao sysDeptExtDao;

    /*************** 2020-10-10 16:10:00 sysdeptDao改为sysDeptMapper 孙文文  MOD  START ***************/
    @Autowired
    SysDeptMapper sysDeptDao;
    /*************** 2020-10-10 16:10:00 sysdeptDao改为sysDeptMapper 孙文文  MOD  END ***************/
    @Autowired
    SysUserDao sysUserDao;
    @Autowired
    private SysDeptConfig sysDeptConfig;
    /*************** 2020-10-10 16:10:00 增加204有 中台无的 list方法 孙文文  MOD  START ***************/
    @Override
    public IPage<SysDeptEntity> list(Page page, SysDeptEntity dto) {
        // 检索条件中含有特殊字符（%、_）进行转译处理
        if (CommonUtils.checkStringObject(dto.getName())) {
            String deptName = (String) dto.getName();
            if (CommonUtils.check(deptName)) {
                deptName = CommonUtils.replaceSqlLikeField(deptName);
                dto.setName(deptName);
            }
        }
        if (StringUtils.isNotBlank(dto.getSort())) {
            if (dto.getSort().startsWith(Constant.ASC)) {
                dto.setSort(Constant.ASC);
            } else {
                dto.setSort(Constant.DESC);
            }
        }
        IPage<SysDeptEntity> pageData = sysDeptDao.findPage(page, dto);
        // 根据检索记录分别查询该机构下人员以及岗位数
        if (pageData.getRecords() != null && pageData.getRecords().size() > 0) {
            SysDeptEntity SysDeptEntityTemp;
            for (int i = 0; i < pageData.getRecords().size(); i++) {
                SysDeptEntityTemp = pageData.getRecords().get(i);
                SysDeptEntityTemp.setJobCount(sysDeptDao.selectJobCountByDeptId(SysDeptEntityTemp.getId()));
                SysDeptEntityTemp.setCount(sysDeptDao.selectPersonCountByDeptCode(SysDeptEntityTemp.getId()));
            }
        }
        return pageData;
    }

    /*************** 2020-10-10 16:10:00 增加list方法 孙文文  MOD  END ***************/

    @Override
    public List<SysDeptEntity> list(String pId) {
        //普通管理员，只能查询所属部门及子部门的数据
        UserDetail user = this.basegetLoginUser();
        String userDeptId = user.getDeptId();
        if (StringUtils.isBlank(pId)) {
            pId = userDeptId;
        }
        /*************** 2020-10-10 16:10:00 表名统一增加opm前缀 孙文文  MOD  START ***************/

        /*************** 2020-10-10 16:10:00 表名统一增加opm前缀 孙文文  MOD  END ***************/
        if (user.getSuperAdmin() == SuperAdminEnum.NO.value()) {
            if (pId.compareTo(userDeptId) > 0) {
                pId = userDeptId;
            }
        }
        //查询部门列表
        QueryWrapper<SysDeptEntity> query = new QueryWrapper<>();
        query.eq("pid", pId).orderByAsc("sort", "id");
        List<SysDeptEntity> entityList = sysDeptDao.selectList(query);
        return entityList;
    }

    @Override
    public List<SysDeptEntity> outList(String pId) {
        //查询部门列表
        QueryWrapper<SysDeptEntity> query = new QueryWrapper<>();
        query.eq("pid", pId).ne("id", "001").orderByAsc("sort", "id");
        List<SysDeptEntity> entityList = sysDeptDao.selectList(query);
        return entityList;
    }

    @Override
    public List<SysDeptExcel> listAll() {
        //普通管理员，只能查询所属部门及子部门的数据
        UserDetail user = this.basegetLoginUser();
        String userDeptId = user.getDeptId();
        logger.info(userDeptId);
        //查询部门列表
        QueryWrapper<SysDeptEntity> query = new QueryWrapper<>();
        query.likeRight("id", userDeptId).orderByAsc("sort", "id");
        List<SysDeptEntity> entityList = sysDeptDao.selectList(query);
        List<SysDeptExcel> excelList = ConvertUtils.sourceToTarget(entityList, SysDeptExcel.class);
        excelList = ConvertDictUtils.formatDicDataList(excelList);
        return excelList;
    }

    @Override
    public List<SysDeptEntity> listAll2() {
        //普通管理员，只能查询所属部门及子部门的数据
        UserDetail user = this.basegetLoginUser();
        String userDeptId = user.getDeptId();
        //查询部门列表
        QueryWrapper<SysDeptEntity> query = new QueryWrapper<>();
        query.likeRight("id", userDeptId).orderByAsc("sort", "id");
        List<SysDeptEntity> entityList = sysDeptDao.selectList(query);
        return entityList;
    }

    @Override
    public SysDeptEntity get(String pkId) {
        //部门ID为null
        if (StringUtils.isBlank(pkId)) {
            return null;
        }
        SysDeptEntity entity = sysDeptDao.selectById(pkId);
        return entity;
    }

    @Override
    public SysDeptEntity getByRealId(String id) {
        //部门ID为null
        if (StringUtils.isBlank(id)) {
            return null;
        }
        SysDeptEntity entity = sysDeptDao.getRealId(id);
        return entity;
    }

    @Override
    public SysDeptEntity getDeptByCode(String code) {
        //部门ID为null
        if (StringUtils.isBlank(code)) {
            return null;
        }
        SysDeptEntity entity = sysDeptDao.getDeptByCode(code);
        return entity;
    }

    /**
     *
     * 加事务加同步锁 简单防止deptid重复 实际应该使用更好的方案
     * @param sysDeptEntity
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public synchronized SysDeptEntity saveDept(SysDeptEntity sysDeptEntity) {
        // 分组任何时候都可以建立
        // 判断父节点,单位 type=1下可以建立机构和部门 分组
        // 判断父节点, 分组一直找,如果是根则什么都可以建,如果是单位什么都可以建,如果是部门只能建分组和部门
        UserDetail userDetail = this.basegetLoginUser();
        String pkId = sysDeptEntity.getPkid();
        if (StringUtils.isBlank(pkId)) {
            // 新的机构添加
            sysDeptEntity.setPkid(IdWorker.get32UUID());
            sysDeptEntity.setId(getDeptId(sysDeptEntity.getPid()));
            sysDeptEntity.setSort(sysDeptEntity.getId());
            sysDeptEntity.setCreator(userDetail.getId());
            sysDeptEntity.setCreateDate(new Date());
            sysDeptEntity.setUpdater(userDetail.getId());
            sysDeptEntity.setUpdateDate(new Date());
            sysDeptEntity.setHasLeaf(true);
            sysDeptEntity.setUpdater(userDetail.getId());
            sysDeptEntity.setUpdateDate(new Date());
            sysDeptDao.insert(sysDeptEntity);
            /*************** 2020-10-13  增加机构后更新父节点的has_leaf状态  MOD   ***************/
            // 更新父节点的has_leaf 字段为0
            sysDeptDao.updateHasLeafById(sysDeptEntity.getPid());
        } else {
            // 更新操作    库中has_leaf字段为0 说明可以展开
            QueryWrapper<SysDeptEntity> query = new QueryWrapper<>();
            query.eq("pid", sysDeptEntity.getId()).select("id");
            //看是否存在子节点
            List<SysDeptEntity> objList = sysDeptDao.selectList(query);
            sysDeptEntity.setUpdater(userDetail.getId());
            sysDeptEntity.setUpdateDate(new Date());
            sysDeptEntity.setHasLeaf(objList.size() == 0);
            sysDeptDao.updateById(sysDeptEntity);
        }
        return sysDeptEntity;
    }

    /**
     * @return
     */
    private String getDeptId(String pId) {
        QueryWrapper<SysDeptEntity> query = new QueryWrapper<>();
        query.eq("pid", pId).select("max(id) as id ").comment("取父节点下最大机构ID");
        List<Map<String, Object>> mapList = sysDeptDao.selectMaps(query);
        Integer id = 0;
        String strId = "";
        /*************** 2020-10-12  增加非空判断孙文文  MOD   ***************/
        //if (mapList.size() > 0) {
        if (mapList.get(0) != null && mapList.size() > 0) {
            Object objValue = mapList.get(0).get("id");
            strId = String.valueOf(objValue);
            strId = strId.substring(strId.length() - 3);
            id = Ten2ThirtyUtils.thirtysixToTen(strId);
        }
        id++;
        strId = Ten2ThirtyUtils.tenTo36(id, "000").toUpperCase();
        return pId + strId;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delete(String pkId) {
        //判断是否有子部门
        SysDeptEntity sysDeptEntity = sysDeptDao.selectById(pkId);
        QueryWrapper<SysDeptEntity> queryDept = new QueryWrapper<>();
        queryDept.eq("pid", sysDeptEntity.getId()).select("id");
        List<SysDeptEntity> objList = sysDeptDao.selectList(queryDept);
        if (objList.size() > 0) {
            throw new RenException(ErrorCode.DEPT_SUB_DELETE_ERROR);
        }

        //判断部门下面是否有用户
        QueryWrapper<SysUserEntity> queryUser = new QueryWrapper<>();
        queryUser.eq("dept_pkid", pkId);
        int count = sysUserDao.selectCount(queryUser);
        if (count > 0) {
            throw new RenException(ErrorCode.DEPT_USER_DELETE_ERROR);
        }
        //删除
        sysDeptDao.deleteById(pkId);
        /*************** 2020-10-13  此处修改为传参pid sww  MOD   ***************/
        setDeptNodeLeaf(sysDeptEntity.getPid());
    }


    /**
     * 设置某个节点是否为叶子节点
     * @param
     * @param
     */

    private void setDeptNodeLeaf(String id) {

        String strSql = "";
        QueryWrapper<SysDeptEntity> query = new QueryWrapper<>();
        // 判断当前节点下有无其他节点
        query.eq("pid", id).select("id");
        List<SysDeptEntity> objList = sysDeptDao.selectList(query);
        query = new QueryWrapper<>();
        query.eq("id", id).select("pkid");
        SysDeptEntity sysDeptEntity = sysDeptDao.selectOne(query);
		/*************** 2020-10-12  对sysDeptEntity的非空判断 sww  MOD   ***************/
        if(!org.springframework.util.StringUtils.isEmpty(sysDeptEntity)){
			sysDeptEntity.setHasLeaf(objList.size() == 0);
			sysDeptDao.updateById(sysDeptEntity);
		}

    }

    /**
     * 保存排序 pkid1 和 pkid2 交换sort
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveDeptSort(String pkId1, String pkId2) {
        String sort1, sort2;

        QueryWrapper<SysDeptEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("pkid", pkId1).select("sort");
        SysDeptEntity sysDeptEntity = sysDeptDao.selectOne(queryWrapper);
        sort1 = sysDeptEntity.getSort();

        queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("pkid", pkId2).select("sort");
        sysDeptEntity = sysDeptDao.selectOne(queryWrapper);
        sort2 = sysDeptEntity.getSort();

        UpdateWrapper<SysDeptEntity> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("pkid", pkId1).set("sort", sort2);
        sysDeptDao.update(new SysDeptEntity(), updateWrapper);

        updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("pkid", pkId2).set("sort", sort1);
        sysDeptDao.update(new SysDeptEntity(), updateWrapper);


    }

    @Override
    public String getDeptIdByPkId(String pkId) {
        QueryWrapper<SysDeptEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("pkid", pkId).select("id");
        SysDeptEntity sysDeptEntity = sysDeptDao.selectOne(queryWrapper);
        return sysDeptEntity.getId();
    }

    @Override
    public String getDeptPkIdById(String deptId) {
        QueryWrapper<SysDeptEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("id", deptId).select("pkid");
        SysDeptEntity sysDeptEntity = sysDeptDao.selectOne(queryWrapper);
        return sysDeptEntity.getPkid();
    }

    //region 赵爱增加 取单位列表 实现前端选择单位 2020-8-28

    /**
     * 根据父级单位ID查询单位列表
     *
     * @param pId 父级单位ID
     * @return Result 单位列表
     */
    @Override
    public List<Map<String, Object>> getDeptList(String pId) {
        QueryWrapper<SysDeptEntity> query = new QueryWrapper<>();
        query.eq("pid", pId).orderByAsc("sort", "id");
        List<SysDeptEntity> entityList = sysDeptDao.selectList(query);
        List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();

        query = new QueryWrapper<>();
        query.groupBy("pid");
        query.select("pid,count(1) as count ");
        List<Map<String, Object>> deptCountList = sysDeptDao.selectMaps(query);

        for (SysDeptEntity deptEntity : entityList) {
            int count = 0;
            for (Map<String, Object> deptMap : deptCountList) {
                if (deptMap.get("pid").equals(deptEntity.getId())) {
                    count = ((Long) deptMap.get("count")).intValue();
                    break;
                }
            }
            Map<String, Object> map = Convert.toMap(String.class, Object.class, deptEntity);
            map.put("checked", false);
            map.put("count", count);
            result.add(map);
        }
        return result;
    }

    /**
     * 根据组织名称查询组织列表
     *
     * @param deptName 组织名称
     * @return List<Map < String, Object>> 组织列表
     */
    @Override
    public List<Map<String, Object>> getDeptListByName(String deptName) {
        QueryWrapper<SysDeptEntity> query = new QueryWrapper<>();
        query.like("name", deptName).orderByAsc("sort", "id");
        List<SysDeptEntity> entityList = sysDeptDao.selectList(query);
        List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();

        query = new QueryWrapper<>();
        query.groupBy("pid");
        query.select("pid,count(1) as count ");
        List<Map<String, Object>> deptCountList = sysDeptDao.selectMaps(query);

        for (SysDeptEntity deptEntity : entityList) {
            int count = 0;
            for (Map<String, Object> deptMap : deptCountList) {
                if (deptMap.get("pid").equals(deptEntity.getId())) {
                    count = ((Long) deptMap.get("count")).intValue();
                    break;
                }
            }
            Map<String, Object> map = Convert.toMap(String.class, Object.class, deptEntity);
            map.put("checked", false);
            map.put("count", count);
            result.add(map);
        }
        return result;
    }

    /**
     * 获取已选择组织机构
     *
     * @param ids 已选择组织机构ID
     * @return List<Map < String, Object>> 组织列表
     */
    @Override
    public List<Map<String, Object>> getSelectedDeptList(String ids) {
        List utList = Arrays.asList(ids.split(","));
        List<SysDeptEntity> entityList = sysDeptDao.selectBatchIds(utList);
        List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
        QueryWrapper<SysDeptEntity> query = new QueryWrapper<>();
        query.groupBy("pid");
        query.select("pid,count(1) as count ");
        List<Map<String, Object>> deptCountList = sysDeptDao.selectMaps(query);
        for (SysDeptEntity deptEntity : entityList) {
            int count = 0;
            for (Map<String, Object> deptMap : deptCountList) {
                if (deptMap.get("pid").equals(deptEntity.getId())) {
                    count = ((Long) deptMap.get("count")).intValue();
                    break;
                }
            }
            Map<String, Object> map = Convert.toMap(String.class, Object.class, deptEntity);
            map.put("checked", true);
            map.put("count", count);
            result.add(map);
        }
        return result;
    }
//endregion


    //region sww增加  因sys_user表中不再存deptname，增加查询方法 2020-9-18

    /**
     * 根据机构名称查询机构id
     *
     * @param deptName 部门机构名称
     * @return String  部门机构名称
     */
    @Override
    public String getDeptIdByName(String deptName) {
        QueryWrapper<SysDeptEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name", deptName).select("id");
        SysDeptEntity sysDeptEntity = sysDeptDao.selectOne(queryWrapper);
        return sysDeptEntity.getPkid();
    }

    @Override
    public List<SysDeptTreeDto2> getDeptTree(String pid) {
        QueryWrapper<SysDeptEntity> query = new QueryWrapper<>();
        List<SysDeptTreeDto2> deptList = new ArrayList<>();

        query.eq("pid", pid);
        SysDeptEntity deptEntity = sysDeptDao.selectOne(query);
        if (deptEntity != null) {
            deptList = getDeptList(deptEntity.getId(), new ArrayList<>());
        }
        //转换DTO 主要为了减少传到前端的数据量
        List<SysDeptTreeDto2> dtoList = ConvertUtils.sourceToTarget(deptList, SysDeptTreeDto2.class);
        return this.build(dtoList);
    }
    /**
     * 递归查询部门
     *
     * @param
     * @return
     */
    private List<SysDeptTreeDto2> getDeptList(String pid, List<SysDeptTreeDto2> list) {

        QueryWrapper<SysDeptEntity> query = new QueryWrapper<>();
        if (StringUtils.isBlank(pid)) {
          throw new RenException("pid不能为空");
        }
        query.eq("pid",pid);
        List<SysDeptEntity> deptList = sysDeptDao.selectList(query);
        List<SysDeptTreeDto2> deptList1 = ConvertUtils.sourceToTarget(deptList, SysDeptTreeDto2.class);
        if (CollectionUtils.isNotEmpty(deptList)) {
            for (SysDeptTreeDto2 dept : deptList1) {
                list.add(dept);
                getDeptList(dept.getId(), list);
            }
        }
        return list;
    }
    /**
     * 构建树节点
     */
    public  <T extends TreeNode> List<T> build(List<T> treeNodes) {
        List<T> result = new ArrayList<>();

        //list转map
        Map<Object, T> nodeMap = new HashMap<>(treeNodes.size());
        for(T treeNode : treeNodes){
            nodeMap.put(treeNode.getId(), treeNode);
        }

        for(T node : nodeMap.values()) {
            //获取当前节点的父节点
            T parent = nodeMap.get(node.getPid());
            if (parent != null && !(node.getId().equals(parent.getId()))) {
                if (CollectionUtils.isNotEmpty(parent.getChildren())) {
                    parent.getChildren().add(node);
                } else {
                    List<T> children = new ArrayList<T>();
                    children.add(node);
                    parent.setChildren(children);
                }
            } else {
                result.add(node);
            }
        }

        return result;
    }

    /*************** 2020-10-10 17:10:00 增加getBreadCrumbsList方法 sww  ADD  START ***************/
    /**
     * 根据选择的机构获取面包屑list
     * @param sysDeptDTO
     * @return
     */
    @Override
    public List<SysDeptEntity> getBreadCrumbsList(SysDeptDTO sysDeptDTO) {
        if (StringUtils.isNotBlank(sysDeptDTO.getPid())) {
            QueryWrapper<SysDeptEntity> queryDept = new QueryWrapper<>();
            //queryDept.eq("has_delete", 0);
            //中台服务器无has_delete字段 以做注释
            queryDept.eq("id", sysDeptDTO.getPid()).select("id", "id", "pid", "name");
            List<SysDeptEntity> objList = sysDeptDao.selectList(queryDept);
            if (objList != null && objList.size() > 0) {
                QueryWrapper<SysDeptEntity> query = new QueryWrapper<>();
                String code = objList.get(0).getId();
                //query.eq("has_delete", 0);
                query.eq("pid", code);
                objList.get(0).setChildCount(sysDeptDao.selectCount(query));
                sysDeptDTO.getSysDeptEntityList().add(objList.get(0));
                sysDeptDTO.setPid(objList.get(0).getPid());
            }
            return getBreadCrumbsList(sysDeptDTO);
        } else {
            return sysDeptDTO.getSysDeptEntityList();
        }
    }


    /*************** 2020-10-10 17:10:00 增加getBreadCrumbsList方法 sww  ADD  END ***************/

    /*************** 2020-10-10 17:10:00 增加getfullpinyin方法 sww  ADD  START ***************/
    @Override
    public String getfullpinyin(String hanzi) {
        StringBuffer pybf = new StringBuffer();
        char[] arr = hanzi.toCharArray();
        HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
        defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > 128) {
                try {
                    pybf.append(PinyinHelper.toHanyuPinyinStringArray(arr[i], defaultFormat)[0]);
                } catch (BadHanyuPinyinOutputFormatCombination e) {
                    e.printStackTrace();
                }
            } else {
                pybf.append(arr[i]);
            }
        }
        return pybf.toString();
    }
    /*************** 2020-10-10 17:10:00 增加getfullpinyin方法 sww  ADD  END ***************/


    /*************** 2020-10-10 17:10:00 增加getCheckErrCode方法 sww  ADD  START ***************/

    /**
     *
     * 保存数据时验证方法
     * @param dto
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public SysDeptDTO getCheckErrCode(SysDeptDTO dto) {
        SysDeptDTO result = new SysDeptDTO();
        result.setErrorCode("0");
        result.setError("");
        Boolean hasParentCompany = false;
        Boolean hasParentDept = false;
        Boolean hasChildDept = false;
        Boolean hasChildCompany = false;
        // add
        if (StringUtils.isBlank(dto.getId())) {
            // 有上级机构
            if (StringUtils.isNotEmpty(dto.getPid())) {
                SysDeptEntity sysDeptEntity = new SysDeptEntity();
                sysDeptEntity.setPid(dto.getPid());
                hasParentDept = checkHasParentDept(sysDeptEntity);

                // 上级有无法人单位判断
                sysDeptEntity = new SysDeptEntity();
                sysDeptEntity.setPid(dto.getPid());
                if (StringUtils.isNotEmpty(getCompanyInfo(sysDeptEntity).getId())) {
                    hasParentCompany = true;
                }
                // 新建单位  上级是内设机构或者上级有内设机构时
                if (dto.getType().equals("1") && (dto.getPtype().equals("2") || hasParentDept)) {
                    // 类型选择错误：上级有内设机构
                    result.setErrorCode("01");
                    result.setError("类型选择错误：上级有内设机构");
                    return result;
                    // 新建内设机构 上级无法人单位时
                } else if (dto.getType().equals("2") && (!hasParentCompany)) {
                    // 类型选择错误：上级无法人单位
                    result.setErrorCode("02");
                    result.setError("类型选择错误：上级无法人单位");
                    return result;
                }

                // 无上级机构
            } else {
                // 添加组织是内设部门时
                if (dto.getType().equals("2")) {
                    // 类型选择错误：无上级法人单位
                    result.setErrorCode("03");
                    result.setError("类型选择错误：无上级法人单位");
                    return result;
                }
            }
            // update
        } else {
            SysDeptEntity sysDeptEntity = sysDeptDao.selectById(dto.getId());
            sysDeptEntity.setPid(dto.getPid());

            SysDeptEntity sysDeptEntityTemp = ConvertUtils.sourceToTarget(sysDeptEntity, SysDeptEntity.class);
            // 上级有无法人单位判断
            if (StringUtils.isNotEmpty(getCompanyInfo(sysDeptEntityTemp).getId())) {
                hasParentCompany = true;
            }
            sysDeptEntityTemp = ConvertUtils.sourceToTarget(sysDeptEntity, SysDeptEntity.class);
            // 下级有无内设机构
            List<SysDeptEntity> childDeptList = new ArrayList<>();
            checkHasChildDept(sysDeptEntityTemp, childDeptList);
            if (childDeptList.size() > 0) {
                hasChildDept = true;
            }

            sysDeptEntityTemp = ConvertUtils.sourceToTarget(sysDeptEntity, SysDeptEntity.class);
            // 下级有无内法人单位
            List<SysDeptEntity> childCompanyList = new ArrayList<>();
            checkHasChildCompany(sysDeptEntityTemp, childCompanyList);
            if (childCompanyList.size() > 0) {
                hasChildCompany = true;
            }

            // 上级有无内设机构
            sysDeptEntityTemp = ConvertUtils.sourceToTarget(sysDeptEntity, SysDeptEntity.class);
            hasParentDept = checkHasParentDept(sysDeptEntityTemp);

            // 单位-》分组的时候
            if (sysDeptEntity.getType().equals("1") && dto.getType().equals("3")) {
                // 上级无法人单位，且下级有内设机构时 报错
                if (!hasParentCompany && hasChildDept) {
                    // 类型选择错误：上级没有法人单位且下级有内设机构
                    result.setErrorCode("1");
                    result.setError("类型选择错误：上级没有法人单位且下级有内设机构");
                    return result;
                }
                // 单位-》内设部门的时候
            } else if (sysDeptEntity.getType().equals("1") && dto.getType().equals("2")) {
                // 类型选择错误：上级没有法人单位
                if (!hasParentCompany) {
                    result.setErrorCode("2");
                    result.setError("类型选择错误：上级没有法人单位");
                    return result;
                    // 类型选择错误：下级有法人单位
                } else if (hasChildCompany) {
                    result.setErrorCode("20");
                    result.setError("类型选择错误：下级有法人单位");
                    return result;
                }
                // 分组-》单位
            } else if (sysDeptEntity.getType().equals("3") && dto.getType().equals("1")) {
                // 类型选择错误：上级有有内设部门
                if (hasParentDept) {
                    result.setErrorCode("3");
                    result.setError("类型选择错误：上级有有内设部门");
                    return result;
                }
                // 分组-》内设部门
            } else if (sysDeptEntity.getType().equals("3") && dto.getType().equals("2")) {
                // 类型选择错误：上级无法人单位
                if (!hasParentCompany) {
                    result.setErrorCode("4");
                    result.setError("类型选择错误：上级无法人单位");
                    return result;
                    // 类型选择错误：下级有法人单位
                } else if (hasChildCompany) {
                    result.setErrorCode("5");
                    result.setError("类型选择错误：下级有法人单位");
                    return result;
                }
                // 内设部门-》 单位
            } else if (sysDeptEntity.getType().equals("3") && dto.getType().equals("2")) {
                // 类型选择错误：上级有内设部门
                if (hasParentDept) {
                    result.setErrorCode("6");
                    result.setError("类型选择错误：上级有内设部门");
                    return result;
                }
            }
        }
        return result;
    }
    /*************** 2020-10-10 17:10:00 增加getCheckErrCode方法 sww  ADD  END ***************/


    /*************** 2020-10-10 17:10:00 增加checkHasParentDept方法 sww  ADD  START ***************/

    /**
     * 判断上级有无内设机构
     * @param sysDeptEntityRst
     * @return
     */
    public Boolean checkHasParentDept(SysDeptEntity sysDeptEntityRst) {
        if (StringUtils.isNotBlank(sysDeptEntityRst.getPid())) {
            QueryWrapper<SysDeptEntity> queryDept = new QueryWrapper<>();
            //queryDept.eq("has_delete", 0);
            queryDept.eq("id", sysDeptEntityRst.getPid()).select("id", "pid", "name", "type");
            List<SysDeptEntity> objList = sysDeptDao.selectList(queryDept);
            if (objList != null && objList.size() > 0 && objList.get(0).getType().equals("2")) {
                return true;
            } else if (objList != null && objList.size() > 0 && StringUtils.isEmpty(objList.get(0).getPid())) {
                return false;
            } else if (objList != null && objList.size() > 0) {
                sysDeptEntityRst.setPid(objList.get(0).getPid());
                return checkHasParentDept(sysDeptEntityRst);
            } else {
                return false;
            }
        } else {
            return false;
        }
    }
    /*************** 2020-10-10 17:10:00 增加getCheckErrCode方法 sww  ADD  END ***************/


    /*************** 2020-10-10 17:10:00 增加getCompanyInfo方法 sww  ADD  START ***************/

    /**
     * 获取单位信息
     */
    public SysDeptEntity getCompanyInfo(SysDeptEntity sysDeptEntityRst) {
        if (StringUtils.isNotBlank(sysDeptEntityRst.getPid())) {
            QueryWrapper<SysDeptEntity> queryDept = new QueryWrapper<>();
            //queryDept.eq("has_delete", 0);
            queryDept.eq("id", sysDeptEntityRst.getPid()).select("id", "pid", "name", "type");
            List<SysDeptEntity> objList = sysDeptDao.selectList(queryDept);
            if (objList != null && objList.size() > 0 && objList.get(0).getType().equals("1")) {
                return objList.get(0);
            } else if (objList != null && objList.size() > 0 && StringUtils.isEmpty(objList.get(0).getPid())) {
                return new SysDeptEntity();
            } else if (objList != null && objList.size() > 0) {
                sysDeptEntityRst.setPid(objList.get(0).getPid());
                return getCompanyInfo(sysDeptEntityRst);
            } else {
                return new SysDeptEntity();
            }
        } else {
            return sysDeptEntityRst;
        }
    }
    /*************** 2020-10-10 17:10:00 增加getCompanyInfo方法 孙文文  ADD  END ***************/


    /*************** 2020-10-10 18:10:00 增加checkHasChildCompany方法 孙文文  ADD  START ***************/

    /**
     * 判断组织下有无法人单位
     * @param sysDeptEntity
     * @return
     */
    private List<SysDeptEntity> checkHasChildCompany(SysDeptEntity sysDeptEntity, List<SysDeptEntity> resultList) {

        QueryWrapper<SysDeptEntity> queryDept = new QueryWrapper<>();
        //queryDept.eq("has_delete", 0);
        queryDept.eq("pid", sysDeptEntity.getId()).select("id", "pid", "name", "type");
        List<SysDeptEntity> sysDeptEntityList = sysDeptDao.selectList(queryDept);
        if (sysDeptEntityList != null && sysDeptEntityList.size() > 0) {
            for (int i = 0; i < sysDeptEntityList.size(); i++) {
                sysDeptEntity = sysDeptEntityList.get(i);
                if (sysDeptEntity.getType().equals("1")) {
                    resultList.add(sysDeptEntity);
                    return resultList;
                } else {
                    checkHasChildCompany(sysDeptEntity, resultList);
                }
            }
        }
        return resultList;
    }
    /*************** 2020-10-10 18:10:00 增加checkHasChildCompany方法 孙文文  ADD  END ***************/

    /*************** 2020-10-10 18:10:00 增加checkHasChildDept方法 孙文文  ADD  START ***************/

    /**
     * 判断组织下有无内设机构
     * @param sysDeptEntity
     * @return
     */
    private List<SysDeptEntity> checkHasChildDept(SysDeptEntity sysDeptEntity, List<SysDeptEntity> resultList) {

        QueryWrapper<SysDeptEntity> queryDept = new QueryWrapper<>();
        //queryDept.eq("has_delete", 0);
        queryDept.eq("pid", sysDeptEntity.getId()).select("id", "pid", "name", "type");
        List<SysDeptEntity> sysDeptEntityList = sysDeptDao.selectList(queryDept);
        if (sysDeptEntityList != null && sysDeptEntityList.size() > 0) {
            for (int i = 0; i < sysDeptEntityList.size(); i++) {
                sysDeptEntity = sysDeptEntityList.get(i);
                if (sysDeptEntity.getType().equals("1")) {
                    continue;
                } else if (sysDeptEntity.getType().equals("2")) {
                    resultList.add(sysDeptEntity);
                    return resultList;
                } else {
                    checkHasChildDept(sysDeptEntity, resultList);
                }
            }
        }
        return resultList;
    }
    /*************** 2020-10-10 18:10:00 增加checkHasChildDept方法 孙文文  ADD  END ***************/

    /**
     * 获取磅房管理详情
     * @param map
     * @return
     */
    @Override
    public IPage<SysDeptEntity> page(Map<String, Object> params) {
        LambdaQueryWrapper<SysDeptEntity> query = Wrappers.lambdaQuery();
        query.like(SysDeptEntity::getId,params.get("deptId"));
        query.eq(!ObjectUtils.isEmpty(params.get("pid")),SysDeptEntity::getPid,params.get("pid"));
        IPage<SysDeptEntity> list = sysDeptDao.selectPage(new Page(Long.parseLong(String.valueOf(params.get("current"))),Long.parseLong(String.valueOf(params.get("size")))),query);
        return list;
    }

}
